package com.powernode.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.powernode.constant.ProductConstants;
import com.powernode.domain.Category;
import com.powernode.ex.handler.BusinessException;
import com.powernode.mapper.CategoryMapper;
import com.powernode.service.CategoryService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.Caching;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;

/**
 * <p>
 * 产品类目 服务实现类
 * </p>
 *
 * @author 付作巍
 * @since 2024-08-17
 */
@Service
@CacheConfig(cacheNames = "com.powernode.service.impl.CategoryServiceImpl")
public class CategoryServiceImpl extends ServiceImpl<CategoryMapper, Category> implements CategoryService {
    @Autowired
    private CategoryMapper categoryMapper;

    /**
     * 查询商品所有类目
      * @return 返回商品类目集合
     */
    @Override
    @Cacheable(key = ProductConstants.ALL_CATEGORY_LIST_KEY) //添加缓存
    public List<Category> queryAllCategoryList() {
        return categoryMapper.selectList(new LambdaQueryWrapper<Category>()
                .orderByDesc(Category::getSeq)       //根据创建时间排序
        );
    }

    /**
     * 查询系统商品的一级类目
     * @return
     */
    @Override
    @Cacheable(key = ProductConstants.FIRST_CATEGORY_LIST_KEY) //添加缓存，不需要再次读取数据库，只需要从redis中获取即可
    public List<Category> queryFirstCategoryList() {
        return categoryMapper.selectList(new LambdaQueryWrapper<Category>()
                .eq(Category::getParentId,0)
                        .eq(Category::getStatus,1)  //当状态是正常时才可以使用
                .orderByDesc(Category::getSeq)
        );
    }

    /**
     * 新增商品类目
     * @param category 商品类目对象
     * @return
     */
    @Override
    @Caching(evict = {   //@Caching 是一个复合注解，该注解标识了清除两个需要清除的内容
            @CacheEvict(key = ProductConstants.ALL_CATEGORY_LIST_KEY),   //@CacheEvict 注解是清除缓存
            @CacheEvict(key = ProductConstants.FIRST_CATEGORY_LIST_KEY),     //清除之前的缓存
            @CacheEvict(key = ProductConstants.WX_PROD_TAG)
    })
    public Boolean saveCategory(Category category) {
        category.setCreateTime(new Date());
        category.setUpdateTime(new Date());
        return categoryMapper.insert(category) > 0;
    }

    /**
     * 修改商品类目信息
     *      需求： 允许商品类目修改类目级别
     * @param category 商品类目对象
     * @return
     */
    @Override
    @Caching(evict = {   //@Caching 是一个复合注解，该注解标识了清除两个需要清除的内容
            @CacheEvict(key = ProductConstants.ALL_CATEGORY_LIST_KEY),   //@CacheEvict 注解是清除缓存
            @CacheEvict(key = ProductConstants.FIRST_CATEGORY_LIST_KEY),     //清除之前的缓存
            @CacheEvict(key = ProductConstants.WX_PROD_TAG)
    })
    public Boolean modifyCategory(Category category) {
        // 修改后的pid
        Long parentId = category.getParentId();
        // 根据标识查询修改之前的类目详情
        Category beforeCategory = categoryMapper.selectById(category.getCategoryId());
        // 获取商品类目之前的级别,如果parentId是0，即为一级类目，不为0即为二级类目
        Long beforeParentId = beforeCategory.getParentId();
        // 判断商品类目修改的情况
         // 如果是一级变二级:之前的parentId为0，修改后的parentId不为0
        if (0 == beforeParentId && null != parentId && 0 != parentId){
            // 查看当前类目下是否包含子类目，如果包含子类目，则不允许修改
            // 根据当前类目标识查询子类目
            List<Category> childList = categoryMapper.selectList(new LambdaQueryWrapper<Category>()
                    .eq(Category::getParentId,category.getCategoryId())
            );  // 查询的是子类目集合

            // 判断当前类目下是否有值
            if (CollectionUtil.isNotEmpty(childList) && childList.size() !=0){
                // 说明当前类目包含子类目，不允许修改
                throw new BusinessException("当前类目包含子类目，不允许修改 ！ ");
            }
        }

        // 二级变一级类目：之前的pid不为0，当前的pid为null
        if ( 0 != beforeParentId && null == parentId){
            category.setCategoryId(0L);
        }
        return categoryMapper.updateById(category)>0;
    }

    /**
     * 删除类目信息
     *      需求：如果一级类目包含子类目，则不可删除，不好含直接删除
     * @param categoryId 商品类目id
     * @return
     */
    @Override
    @Caching(evict = {   //@Caching 是一个复合注解，该注解标识了清除两个需要清除的内容
            @CacheEvict(key = ProductConstants.ALL_CATEGORY_LIST_KEY),   //@CacheEvict 注解是清除缓存
            @CacheEvict(key = ProductConstants.FIRST_CATEGORY_LIST_KEY),     //清除之前的缓存
            @CacheEvict(key = ProductConstants.WX_PROD_TAG)
    })
    public Boolean removeCategoryById(Long categoryId) {
        // 根据类目标识查询子类目集合
        List<Category> chileCategoryList = categoryMapper.selectList(new LambdaQueryWrapper<Category>()
                .eq(Category::getParentId,categoryId)
        );
        // 判断是否有值
        if (CollectionUtil.isNotEmpty(chileCategoryList) && chileCategoryList.size() !=0){
            // 说明当前类目包含子类目，不可以删除
            throw new BusinessException("当前类目包含子类目，不允许删除 ！！  ");
        }

        // 说明当前类目不包含子类目
        return categoryMapper.deleteById(categoryId) > 0;
    }

    /**
     * 查询小程序中商品的一级类目集合
     * @param pid 父id
     * @return
     */
    @Override
    @Cacheable(key = ProductConstants.WX_FIRST_CATEGORY)
    public List<Category> queryWxCategoryListByPid(Long pid) {
        return categoryMapper.selectList(new LambdaQueryWrapper<Category>()
                .eq(Category::getStatus,1)
                .eq(Category::getParentId,pid)
                .orderByDesc(Category::getSeq)
        );
    }
}
